package ixOrm

import (
	"context"
	"fmt"
	"log"
	"reflect"
	"strings"

	"gorm.io/gorm"
)

// debugLog 打印debug日志
func (t *TableOperator) debugLog(format string, args ...interface{}) {
	if t.client != nil && t.client.config != nil && t.client.config.DebugMode {
		log.Printf("[ixOrm-DEBUG] "+format, args...)
	}
}

// Create 创建记录
func (t *TableOperator) Create(model interface{}, opts ...*CreateOptions) error {
	if t == nil || t.db == nil {
		return fmt.Errorf("数据库连接未初始化")
	}

	options := &CreateOptions{
		TableName:   t.tableName,
		AutoMigrate: true,
		Context:     context.Background(),
	}
	if len(opts) > 0 && opts[0] != nil {
		if opts[0].Context != nil {
			options.Context = opts[0].Context
		}
		if opts[0].TableName != "" {
			options.TableName = opts[0].TableName
		}
		options.AutoMigrate = opts[0].AutoMigrate
		options.Extensions = opts[0].Extensions
	}

	// 尝试插入数据
	err := t.db.WithContext(options.Context).Create(model).Error

	// 如果是表不存在错误且启用自动迁移，则创建表后重试
	if err != nil && t.isTableNotExistError(err) && options.AutoMigrate {
		if createErr := t.autoCreateTable(model); createErr != nil {
			return fmt.Errorf("自动创建表失败: %w", createErr)
		}
		// 重新尝试插入
		err = t.db.WithContext(options.Context).Create(model).Error
	}

	if err != nil {
		return fmt.Errorf("创建记录失败: %w", err)
	}

	// 不自动清除缓存，让缓存自然过期或手动清除

	return nil
}

// CreateInBatches 批量创建记录
func (t *TableOperator) CreateInBatches(models interface{}, batchSize int, opts ...*CreateOptions) error {
	if t == nil || t.db == nil {
		return fmt.Errorf("数据库连接未初始化")
	}

	options := &CreateOptions{
		TableName:   t.tableName,
		AutoMigrate: true,
		Context:     context.Background(),
	}
	if len(opts) > 0 && opts[0] != nil {
		if opts[0].Context != nil {
			options.Context = opts[0].Context
		}
		if opts[0].TableName != "" {
			options.TableName = opts[0].TableName
		}
		options.AutoMigrate = opts[0].AutoMigrate
	}

	err := t.db.WithContext(options.Context).CreateInBatches(models, batchSize).Error

	// 如果是表不存在错误且启用自动迁移，则创建表后重试
	if err != nil && t.isTableNotExistError(err) && options.AutoMigrate {
		if createErr := t.autoCreateTable(models); createErr != nil {
			return fmt.Errorf("自动创建表失败: %w", createErr)
		}
		err = t.db.WithContext(options.Context).CreateInBatches(models, batchSize).Error
	}

	if err != nil {
		return fmt.Errorf("批量创建记录失败: %w", err)
	}

	// 不自动清除缓存，让缓存自然过期或手动清除

	return nil
}

// Upsert 插入或更新记录（根据主键判断）
// 参数：insertData 插入时用的数据，updateData 更新时用的数据（可选）
func (t *TableOperator) Upsert(insertData interface{}, updateData ...interface{}) error {
	if t == nil || t.db == nil {
		return fmt.Errorf("数据库连接未初始化")
	}

	// 如果只传了一个参数，使用传统的 Save 方法
	if len(updateData) == 0 {
		// 尝试执行 upsert 操作
		err := t.db.WithContext(context.Background()).Save(insertData).Error

		// 如果是表不存在错误，则创建表后重试
		if err != nil && t.isTableNotExistError(err) {
			if createErr := t.autoCreateTable(insertData); createErr != nil {
				return fmt.Errorf("自动创建表失败: %w", createErr)
			}
			// 重新尝试 upsert
			err = t.db.WithContext(context.Background()).Save(insertData).Error
		}

		if err != nil {
			return fmt.Errorf("Upsert记录失败: %w", err)
		}

		return nil
	}

	// 传了两个参数：分别处理插入和更新
	// 首先尝试插入
	err := t.db.WithContext(context.Background()).Create(insertData).Error

	// 如果是表不存在错误，创建表后重试
	if err != nil && t.isTableNotExistError(err) {
		if createErr := t.autoCreateTable(insertData); createErr != nil {
			return fmt.Errorf("自动创建表失败: %w", createErr)
		}
		// 重新尝试插入
		err = t.db.WithContext(context.Background()).Create(insertData).Error
	}

	// 如果插入成功，直接返回
	if err == nil {
		return nil
	}

	// 如果是主键冲突错误，执行更新操作
	if t.isDuplicateKeyError(err) {
		// 获取主键条件
		pkConditions := t.extractPrimaryKeyConditions(insertData)
		if len(pkConditions) == 0 {
			return fmt.Errorf("无法获取主键条件: %w", err)
		}

		// 构建更新查询
		db := t.db.WithContext(context.Background())
		for field, value := range pkConditions {
			if strings.Contains(field, "?") {
				db = db.Where(field, value)
			} else if strings.Contains(field, " ") && !strings.Contains(field, "=") {
				db = db.Where(field+" ?", value)
			} else {
				db = db.Where(field+" = ?", value)
			}
		}

		// 执行更新
		err = db.Updates(updateData[0]).Error
		if err != nil {
			return fmt.Errorf("更新记录失败: %w", err)
		}

		return nil
	}

	// 其他错误直接返回
	return fmt.Errorf("Upsert记录失败: %w", err)
}

// Find 查找记录
func (t *TableOperator) Find(dest interface{}, opts ...*QueryOptions) error {
	if t == nil || t.db == nil {
		return fmt.Errorf("数据库连接未初始化")
	}

	options := &QueryOptions{
		TableName: t.tableName,
		Context:   context.Background(),
		UseCache:  t.useCache,
		CacheTTL:  t.cacheTTL,
	}
	if len(opts) > 0 && opts[0] != nil {
		if opts[0].Context != nil {
			options.Context = opts[0].Context
		}
		if opts[0].TableName != "" {
			options.TableName = opts[0].TableName
		}
		if opts[0].Conditions != nil {
			options.Conditions = opts[0].Conditions
		}
		if opts[0].OrderBy != nil {
			options.OrderBy = opts[0].OrderBy
		}
		if opts[0].GroupBy != nil {
			options.GroupBy = opts[0].GroupBy
		}
		if opts[0].Limit > 0 {
			options.Limit = opts[0].Limit
		}
		if opts[0].Offset > 0 {
			options.Offset = opts[0].Offset
		}
		if opts[0].Select != nil {
			options.Select = opts[0].Select
		}
		options.UseCache = opts[0].UseCache
		options.CacheType = opts[0].CacheType
		if opts[0].CacheKey != "" {
			options.CacheKey = opts[0].CacheKey
		}
		if opts[0].CacheTTL > 0 {
			options.CacheTTL = opts[0].CacheTTL
		}
	}

	// 尝试从缓存获取
	if options.UseCache && t.client.cache != nil {
		cacheKey := options.CacheKey
		if cacheKey == "" {
			cacheKey = t.generateCacheKey("find", options.Conditions, options.OrderBy, options.Limit, options.Offset)
		}

		// 根据CacheType选择缓存实例
		cache := t.client.GetCacheByType(options.CacheType)
		if exists, err := cache.Get(cacheKey, dest); err == nil && exists {
			// 缓存命中
			cacheTypeName := "unknown"
			switch options.CacheType {
			case CacheTypeRedis:
				cacheTypeName = "Redis"
			case CacheTypeMemory:
				cacheTypeName = "Memory"
			case CacheTypeNone:
				cacheTypeName = "None"
			}
			t.debugLog("缓存命中 [%s] - Key: %s", cacheTypeName, cacheKey)
			return nil
		} else {
			// 缓存未命中
			cacheTypeName := "unknown"
			switch options.CacheType {
			case CacheTypeRedis:
				cacheTypeName = "Redis"
			case CacheTypeMemory:
				cacheTypeName = "Memory"
			case CacheTypeNone:
				cacheTypeName = "None"
			}
			t.debugLog("缓存未命中 [%s] - Key: %s", cacheTypeName, cacheKey)
		}
	}

	// 构建查询
	db := t.buildQuery(options)

	// 执行查询
	err := db.Find(dest).Error

	// 如果是表不存在错误，返回空结果而不是错误
	if err != nil && t.isTableNotExistError(err) {
		// 表不存在时返回空数据，但仍然需要缓存空结果防止缓存穿透
		if options.UseCache && t.client.cache != nil {
			cacheKey := options.CacheKey
			if cacheKey == "" {
				cacheKey = t.generateCacheKey("find", options.Conditions, options.OrderBy, options.Limit, options.Offset)
			}

			ttl := options.CacheTTL
			if ttl == 0 {
				ttl = t.client.config.CacheTTL
			}

			// 根据CacheType选择缓存实例
			cache := t.client.GetCacheByType(options.CacheType)
			cache.Set(cacheKey, dest, ttl) // 缓存空结果

			// 缓存存储日志
			cacheTypeName := "unknown"
			switch options.CacheType {
			case CacheTypeRedis:
				cacheTypeName = "Redis"
			case CacheTypeMemory:
				cacheTypeName = "Memory"
			case CacheTypeNone:
				cacheTypeName = "None"
			}
			t.debugLog("空结果存储到缓存 [%s] - Key: %s, TTL: %v", cacheTypeName, cacheKey, ttl)
		}
		return nil // 表不存在时返回空数据
	}

	if err != nil {
		return fmt.Errorf("查找记录失败: %w", err)
	}

	// 缓存结果
	if options.UseCache && t.client.cache != nil {
		cacheKey := options.CacheKey
		if cacheKey == "" {
			cacheKey = t.generateCacheKey("find", options.Conditions, options.OrderBy, options.Limit, options.Offset)
		}

		ttl := options.CacheTTL
		if ttl == 0 {
			ttl = t.client.config.CacheTTL
		}

		// 根据CacheType选择缓存实例
		cache := t.client.GetCacheByType(options.CacheType)
		cache.Set(cacheKey, dest, ttl)

		// 缓存存储日志
		cacheTypeName := "unknown"
		switch options.CacheType {
		case CacheTypeRedis:
			cacheTypeName = "Redis"
		case CacheTypeMemory:
			cacheTypeName = "Memory"
		case CacheTypeNone:
			cacheTypeName = "None"
		}
		t.debugLog("数据存储到缓存 [%s] - Key: %s, TTL: %v", cacheTypeName, cacheKey, ttl)
	}

	return nil
}

// FindOne 查找单条记录
func (t *TableOperator) FindOne(dest interface{}, opts ...*QueryOptions) error {
	if t == nil || t.db == nil {
		return fmt.Errorf("数据库连接未初始化")
	}

	options := &QueryOptions{
		TableName: t.tableName,
		Context:   context.Background(),
		Limit:     1,
		UseCache:  t.useCache,
		CacheTTL:  t.cacheTTL,
	}
	if len(opts) > 0 && opts[0] != nil {
		*options = *opts[0]
		options.Limit = 1
	}

	// 尝试从缓存获取
	if options.UseCache && t.client.cache != nil {
		cacheKey := options.CacheKey
		if cacheKey == "" {
			cacheKey = t.generateCacheKey("findone", options.Conditions)
		}

		// 根据CacheType选择缓存实例
		cache := t.client.GetCacheByType(options.CacheType)
		if exists, err := cache.Get(cacheKey, dest); err == nil && exists {
			// 缓存命中
			cacheTypeName := "unknown"
			switch options.CacheType {
			case CacheTypeRedis:
				cacheTypeName = "Redis"
			case CacheTypeMemory:
				cacheTypeName = "Memory"
			case CacheTypeNone:
				cacheTypeName = "None"
			}
			t.debugLog("缓存命中 [%s] - Key: %s", cacheTypeName, cacheKey)
			return nil
		} else {
			// 缓存未命中
			cacheTypeName := "unknown"
			switch options.CacheType {
			case CacheTypeRedis:
				cacheTypeName = "Redis"
			case CacheTypeMemory:
				cacheTypeName = "Memory"
			case CacheTypeNone:
				cacheTypeName = "None"
			}
			t.debugLog("缓存未命中 [%s] - Key: %s", cacheTypeName, cacheKey)
		}
	}

	// 构建查询
	db := t.buildQuery(options)

	// 执行查询
	err := db.First(dest).Error

	// 如果是表不存在错误，返回空结果而不是错误
	if err != nil && t.isTableNotExistError(err) {
		// 表不存在时返回记录未找到错误，但仍然需要缓存空结果防止缓存穿透
		if options.UseCache && t.client.cache != nil {
			cacheKey := options.CacheKey
			if cacheKey == "" {
				cacheKey = t.generateCacheKey("findone", options.Conditions)
			}

			ttl := options.CacheTTL
			if ttl == 0 {
				ttl = t.client.config.CacheTTL
			}

			// 根据CacheType选择缓存实例
			cache := t.client.GetCacheByType(options.CacheType)
			cache.Set(cacheKey, dest, ttl) // 缓存空结果

			// 缓存存储日志
			cacheTypeName := "unknown"
			switch options.CacheType {
			case CacheTypeRedis:
				cacheTypeName = "Redis"
			case CacheTypeMemory:
				cacheTypeName = "Memory"
			case CacheTypeNone:
				cacheTypeName = "None"
			}
			t.debugLog("空结果存储到缓存 [%s] - Key: %s, TTL: %v", cacheTypeName, cacheKey, ttl)
		}
		return nil // 表不存在时返回空结果
	}

	// 缓存结果
	if options.UseCache && t.client.cache != nil && err == nil {
		cacheKey := options.CacheKey
		if cacheKey == "" {
			cacheKey = t.generateCacheKey("findone", options.Conditions)
		}

		ttl := options.CacheTTL
		if ttl == 0 {
			ttl = t.client.config.CacheTTL
		}

		// 根据CacheType选择缓存实例
		cache := t.client.GetCacheByType(options.CacheType)
		cache.Set(cacheKey, dest, ttl)

		// 缓存存储日志
		cacheTypeName := "unknown"
		switch options.CacheType {
		case CacheTypeRedis:
			cacheTypeName = "Redis"
		case CacheTypeMemory:
			cacheTypeName = "Memory"
		case CacheTypeNone:
			cacheTypeName = "None"
		}
		t.debugLog("数据存储到缓存 [%s] - Key: %s, TTL: %v", cacheTypeName, cacheKey, ttl)
	}

	if err != nil {
		// 如果是记录不存在错误，也需要缓存空结果防止缓存穿透
		if err == gorm.ErrRecordNotFound && options.UseCache && t.client.cache != nil {
			cacheKey := options.CacheKey
			if cacheKey == "" {
				cacheKey = t.generateCacheKey("findone", options.Conditions)
			}

			ttl := options.CacheTTL
			if ttl == 0 {
				ttl = t.client.config.CacheTTL
			}

			// 根据CacheType选择缓存实例
			cache := t.client.GetCacheByType(options.CacheType)
			cache.Set(cacheKey, dest, ttl) // 缓存空结果

			// 缓存存储日志
			cacheTypeName := "unknown"
			switch options.CacheType {
			case CacheTypeRedis:
				cacheTypeName = "Redis"
			case CacheTypeMemory:
				cacheTypeName = "Memory"
			case CacheTypeNone:
				cacheTypeName = "None"
			}
			t.debugLog("空结果存储到缓存 [%s] - Key: %s, TTL: %v", cacheTypeName, cacheKey, ttl)
		}
		return err
	}

	return nil
}

// Update 更新记录
func (t *TableOperator) Update(updates interface{}, opts ...*UpdateOptions) error {
	if t == nil || t.db == nil {
		return fmt.Errorf("数据库连接未初始化")
	}

	options := &UpdateOptions{
		TableName:  t.tableName,
		Context:    context.Background(),
		ClearCache: true,
	}
	if len(opts) > 0 && opts[0] != nil {
		if opts[0].Context != nil {
			options.Context = opts[0].Context
		}
		if opts[0].TableName != "" {
			options.TableName = opts[0].TableName
		}
		if opts[0].Conditions != nil {
			options.Conditions = opts[0].Conditions
		}
		options.ClearCache = opts[0].ClearCache
	}

	// 构建查询
	db := t.db.WithContext(options.Context)

	// 应用条件
	if options.Conditions != nil {
		for field, value := range options.Conditions {
			if strings.Contains(field, "?") {
				// 如果字段名包含 ?，说明已经是完整的条件，直接使用
				db = db.Where(field, value)
			} else if t.hasOperator(field) {
				// 如果字段名包含操作符，添加 ?
				db = db.Where(field+" ?", value)
			} else {
				// 否则使用默认的等于操作符
				// 使用strings.Builder优化字符串拼接性能
				var builder strings.Builder
				builder.Grow(len(field) + 4) // 预分配空间
				builder.WriteString(field)
				builder.WriteString(" = ?")
				db = db.Where(builder.String(), value)
			}
		}
	}

	// 执行更新
	err := db.Updates(updates).Error
	if err != nil {
		return fmt.Errorf("更新记录失败: %w", err)
	}

	// 不自动清除缓存，让缓存自然过期或手动清除

	return nil
}

// Delete 删除记录
func (t *TableOperator) Delete(opts ...*DeleteOptions) error {
	if t == nil || t.db == nil {
		return fmt.Errorf("数据库连接未初始化")
	}

	options := &DeleteOptions{
		TableName:  t.tableName,
		Context:    context.Background(),
		SoftDelete: true,
		ClearCache: true,
	}
	if len(opts) > 0 && opts[0] != nil {
		if opts[0].Context != nil {
			options.Context = opts[0].Context
		}
		if opts[0].TableName != "" {
			options.TableName = opts[0].TableName
		}
		if opts[0].Conditions != nil {
			options.Conditions = opts[0].Conditions
		}
		options.SoftDelete = opts[0].SoftDelete
		options.ClearCache = opts[0].ClearCache
	}

	// 构建查询
	db := t.db.WithContext(options.Context)

	// 应用条件
	if options.Conditions != nil {
		for field, value := range options.Conditions {
			if strings.Contains(field, "?") {
				// 如果字段名包含 ?，说明已经是完整的条件，直接使用
				db = db.Where(field, value)
			} else if t.hasOperator(field) {
				// 如果字段名包含操作符，添加 ?
				db = db.Where(field+" ?", value)
			} else {
				// 否则使用默认的等于操作符
				// 使用strings.Builder优化字符串拼接性能
				var builder strings.Builder
				builder.Grow(len(field) + 4) // 预分配空间
				builder.WriteString(field)
				builder.WriteString(" = ?")
				db = db.Where(builder.String(), value)
			}
		}
	}

	// 执行删除
	var err error
	if options.SoftDelete {
		err = db.Delete(nil).Error
	} else {
		err = db.Unscoped().Delete(nil).Error
	}

	if err != nil {
		return fmt.Errorf("删除记录失败: %w", err)
	}

	// 不自动清除缓存，让缓存自然过期或手动清除

	return nil
}

// Count 计数记录
func (t *TableOperator) Count(opts ...*QueryOptions) (int64, error) {
	if t == nil || t.db == nil {
		return 0, fmt.Errorf("数据库连接未初始化")
	}

	options := &QueryOptions{
		TableName: t.tableName,
		Context:   context.Background(),
		UseCache:  t.useCache,
		CacheTTL:  t.cacheTTL,
	}
	if len(opts) > 0 && opts[0] != nil {
		if opts[0].Context != nil {
			options.Context = opts[0].Context
		}
		if opts[0].Conditions != nil {
			options.Conditions = opts[0].Conditions
		}
		options.UseCache = opts[0].UseCache
		if opts[0].CacheTTL > 0 {
			options.CacheTTL = opts[0].CacheTTL
		}
	}

	// 尝试从缓存获取
	if options.UseCache && t.client.cache != nil {
		cacheKey := t.generateCacheKey("count", options.Conditions)
		var count int64
		// 根据CacheType选择缓存实例
		cache := t.client.GetCacheByType(options.CacheType)
		if exists, err := cache.Get(cacheKey, &count); err == nil && exists {
			return count, nil
		}
	}

	// 构建查询
	db := t.db.WithContext(options.Context)

	// 应用条件
	if options.Conditions != nil {
		for field, value := range options.Conditions {
			if strings.Contains(field, "?") {
				// 如果字段名包含 ?，说明已经是完整的条件，直接使用
				db = db.Where(field, value)
			} else if t.hasOperator(field) {
				// 如果字段名包含操作符，添加 ?
				db = db.Where(field+" ?", value)
			} else {
				// 否则使用默认的等于操作符
				// 使用strings.Builder优化字符串拼接性能
				var builder strings.Builder
				builder.Grow(len(field) + 4) // 预分配空间
				builder.WriteString(field)
				builder.WriteString(" = ?")
				db = db.Where(builder.String(), value)
			}
		}
	}

	var count int64
	err := db.Count(&count).Error

	// 如果是表不存在错误，返回0
	if err != nil && t.isTableNotExistError(err) {
		// 表不存在时返回0，但仍然需要缓存0结果防止缓存穿透
		if options.UseCache && t.client.cache != nil {
			cacheKey := t.generateCacheKey("count", options.Conditions)
			ttl := options.CacheTTL
			if ttl == 0 {
				ttl = t.client.config.CacheTTL
			}
			// 根据CacheType选择缓存实例
			cache := t.client.GetCacheByType(options.CacheType)
			cache.Set(cacheKey, int64(0), ttl) // 缓存0结果

			// 缓存存储日志
			cacheTypeName := "unknown"
			switch options.CacheType {
			case CacheTypeRedis:
				cacheTypeName = "Redis"
			case CacheTypeMemory:
				cacheTypeName = "Memory"
			case CacheTypeNone:
				cacheTypeName = "None"
			}
			t.debugLog("空结果存储到缓存 [%s] - Key: %s, TTL: %v", cacheTypeName, cacheKey, ttl)
		}
		return 0, nil
	}

	if err != nil {
		return 0, fmt.Errorf("计数记录失败: %w", err)
	}

	// 缓存结果
	if options.UseCache && t.client.cache != nil {
		cacheKey := t.generateCacheKey("count", options.Conditions)
		ttl := options.CacheTTL
		if ttl == 0 {
			ttl = t.client.config.CacheTTL
		}
		// 根据CacheType选择缓存实例
		cache := t.client.GetCacheByType(options.CacheType)
		cache.Set(cacheKey, count, ttl)
	}

	return count, nil
}

// Exists 检查记录是否存在
func (t *TableOperator) Exists(opts ...*QueryOptions) (bool, error) {
	count, err := t.Count(opts...)
	if err != nil {
		return false, err
	}
	return count > 0, nil
}

// buildQuery 构建查询
func (t *TableOperator) buildQuery(options *QueryOptions) *gorm.DB {
	if t == nil || t.db == nil {
		return nil
	}

	db := t.db.WithContext(options.Context)

	// 应用 AND 条件
	if options.Conditions != nil {
		for field, value := range options.Conditions {
			if strings.Contains(field, "?") {
				// 如果字段名包含 ?，说明已经是完整的条件，直接使用
				db = db.Where(field, value)
			} else if t.hasOperator(field) {
				// 如果字段名包含操作符，添加 ?
				db = db.Where(field+" ?", value)
			} else {
				// 否则使用默认的等于操作符
				// 使用strings.Builder优化字符串拼接性能
				var builder strings.Builder
				builder.Grow(len(field) + 4) // 预分配空间
				builder.WriteString(field)
				builder.WriteString(" = ?")
				db = db.Where(builder.String(), value)
			}
		}
	}

	// 应用 OR 条件
	if len(options.OrConditions) > 0 {
		for _, orCondition := range options.OrConditions {
			for field, value := range orCondition {
				// 特殊处理 IS NULL 和 IS NOT NULL
				if strings.HasSuffix(field, " IS NULL") || strings.HasSuffix(field, " IS NOT NULL") {
					db = db.Or(field)
				} else if strings.HasSuffix(field, " BETWEEN") {
					// 处理 BETWEEN 条件
					if values, ok := value.([]interface{}); ok && len(values) == 2 {
						actualField := strings.TrimSuffix(field, " BETWEEN")
						db = db.Or(actualField+" BETWEEN ? AND ?", values[0], values[1])
					}
				} else if strings.Contains(field, "?") {
					db = db.Or(field, value)
				} else if t.hasOperator(field) {
					db = db.Or(field+" ?", value)
				} else {
					var builder strings.Builder
					builder.Grow(len(field) + 4)
					builder.WriteString(field)
					builder.WriteString(" = ?")
					db = db.Or(builder.String(), value)
				}
			}
		}
	}

	// 应用原始 SQL 条件
	if len(options.RawConditions) > 0 {
		for _, rawCond := range options.RawConditions {
			if len(rawCond.Values) > 0 {
				db = db.Where(rawCond.SQL, rawCond.Values...)
			} else {
				db = db.Where(rawCond.SQL)
			}
		}
	}

	// 应用选择字段
	if len(options.Select) > 0 {
		db = db.Select(options.Select)
	}

	// 应用排序
	for _, orderBy := range options.OrderBy {
		db = db.Order(orderBy)
	}

	// 应用分组
	for _, groupBy := range options.GroupBy {
		db = db.Group(groupBy)
	}

	// 应用限制
	if options.Limit > 0 {
		db = db.Limit(options.Limit)
	}

	// 应用偏移
	if options.Offset > 0 {
		db = db.Offset(options.Offset)
	}

	return db
}

// hasOperator 检查字段名是否包含操作符
func (t *TableOperator) hasOperator(field string) bool {
	// 常见的 SQL 操作符
	operators := []string{" >", " <", " >=", " <=", " !=", " <>", " LIKE", " like", " IN", " in", " NOT IN", " not in"}
	for _, op := range operators {
		if strings.Contains(field, op) {
			return true
		}
	}
	return false
}

// isDuplicateKeyError 检查是否是主键冲突错误
func (t *TableOperator) isDuplicateKeyError(err error) bool {
	if err == nil {
		return false
	}
	errStr := strings.ToLower(err.Error())
	return strings.Contains(errStr, "duplicate") ||
		strings.Contains(errStr, "unique") ||
		strings.Contains(errStr, "1062") // MySQL duplicate key error code
}

// extractPrimaryKeyConditions 从模型中提取主键条件（优化版本）
func (t *TableOperator) extractPrimaryKeyConditions(model interface{}) map[string]interface{} {
	conditions := make(map[string]interface{})

	value := reflect.ValueOf(model)
	if value.Kind() == reflect.Ptr {
		value = value.Elem()
	}

	if value.Kind() != reflect.Struct {
		return conditions
	}

	typ := value.Type()

	// 尝试从缓存获取主键字段信息
	reflectMutex.RLock()
	primaryKeys, exists := primaryKeyCache[typ]
	reflectMutex.RUnlock()

	if !exists {
		// 缓存中没有，解析并缓存
		primaryKeys = t.parsePrimaryKeyFields(typ)
		reflectMutex.Lock()
		primaryKeyCache[typ] = primaryKeys
		reflectMutex.Unlock()
	}

	// 使用缓存的主键信息提取值
	for _, fieldName := range primaryKeys {
		if field := value.FieldByName(fieldName); field.IsValid() && field.CanInterface() {
			fieldValue := field.Interface()
			if !isZero(fieldValue) {
				// 转换字段名为数据库字段名
				dbFieldName := t.getDBFieldName(typ, fieldName)
				conditions[dbFieldName] = fieldValue
			}
		}
	}

	// 如果没有找到主键，尝试使用 ID 字段
	if len(conditions) == 0 {
		if idField := value.FieldByName("ID"); idField.IsValid() && idField.CanInterface() {
			idValue := idField.Interface()
			if !isZero(idValue) {
				conditions["id"] = idValue
			}
		}
	}

	return conditions
}

// parsePrimaryKeyFields 解析主键字段（仅在缓存时调用）
func (t *TableOperator) parsePrimaryKeyFields(typ reflect.Type) []string {
	var primaryKeys []string

	for i := 0; i < typ.NumField(); i++ {
		fieldType := typ.Field(i)

		// 跳过非导出字段
		if !fieldType.IsExported() {
			continue
		}

		// 检查是否是主键字段
		tag := fieldType.Tag.Get("gorm")
		if strings.Contains(tag, "primaryKey") || strings.Contains(tag, "primary_key") {
			primaryKeys = append(primaryKeys, fieldType.Name)
		}
	}

	return primaryKeys
}

// getDBFieldName 获取数据库字段名（带缓存优化）
func (t *TableOperator) getDBFieldName(typ reflect.Type, fieldName string) string {
	// 先尝试从缓存获取
	reflectMutex.RLock()
	if fieldMap, exists := dbFieldNameCache[typ]; exists {
		if dbName, found := fieldMap[fieldName]; found {
			reflectMutex.RUnlock()
			return dbName
		}
	}
	reflectMutex.RUnlock()

	// 缓存中没有，计算并缓存
	dbName := fieldName
	if field, found := typ.FieldByName(fieldName); found {
		if jsonTag := field.Tag.Get("json"); jsonTag != "" && jsonTag != "-" {
			if idx := strings.Index(jsonTag, ","); idx != -1 {
				dbName = jsonTag[:idx]
			} else {
				dbName = jsonTag
			}
		}
	}

	// 缓存结果
	reflectMutex.Lock()
	if dbFieldNameCache[typ] == nil {
		dbFieldNameCache[typ] = make(map[string]string)
	}
	dbFieldNameCache[typ][fieldName] = dbName
	reflectMutex.Unlock()

	return dbName
}

// copyCacheData 复制缓存数据到目标
func copyCacheData(dest interface{}, data interface{}) error {
	if dest == nil || data == nil {
		return fmt.Errorf("dest or data is nil")
	}

	destValue := reflect.ValueOf(dest)
	if destValue.Kind() != reflect.Ptr || destValue.IsNil() {
		return fmt.Errorf("dest must be a non-nil pointer")
	}

	elem := destValue.Elem()
	sourceValue := reflect.ValueOf(data)

	// 如果类型匹配，直接赋值
	if sourceValue.Type().AssignableTo(elem.Type()) {
		elem.Set(sourceValue)
		return nil
	}

	// 如果类型可转换，进行转换后赋值
	if sourceValue.Type().ConvertibleTo(elem.Type()) {
		elem.Set(sourceValue.Convert(elem.Type()))
		return nil
	}

	return fmt.Errorf("cannot convert %v to %v", sourceValue.Type(), elem.Type())
}
